set(targetincludes "$<$<BOOL:${targetincludes}>:-I$<JOIN:${targetincludes},\n-I>\n>")

add_custom_command(TARGET ${TARGET}
          POST_BUILD
          COMMAND ${CMAKE_COMMAND} -P copy_${lib_safe_name}_to_${TARGET}$<$<BOOL:${multi_config}>:_$<CONFIG>>.cmake
          DEPENDS $<TARGET_FILE:${TARGET}>
        )

target_compile_definitions(Jolt PUBLIC $<$<BOOL:${MSVC}>:_HAS_EXCEPTIONS=0>)

target_link_libraries(OpenAL PRIVATE alsoft.common ${LINKER_FLAGS} alsoft::fmt
            $<$<BOOL:${HAVE_CXXMODULES}>:alsoft.modules alsoft.router-modules>)

target_compile_definitions(
    ${ra_core_target}
    PUBLIC -DCXX_FILESYSTEM_HAVE_FS
           -DCXX_FILESYSTEM_IS_EXPERIMENTAL=$<BOOL:${CXX_FILESYSTEM_IS_EXPERIMENTAL}>
           -DCXX_FILESYSTEM_NAMESPACE=${CXX_FILESYSTEM_NAMESPACE}
)

target_compile_options(fbx::sdk
      INTERFACE $<$<BOOL:${W_NULL_DEREFERENCE}>:-Wno-null-dereference>
      INTERFACE $<$<BOOL:${W_PRAGMA_PACK}>:-Wno-pragma-pack>)

target_compile_options(${TARGET_NAME} PRIVATE $<$<BOOL:${MSVC}>:/arch:AVX2 /std:c++11>)

target_compile_definitions(${TARGET} INTERFACE PAL_BUILD_PHOENIX2=$<BOOL:${PAL_BUILD_GFX9}>)

target_compile_definitions(${TARGET_NAME}
  PUBLIC
    ASIO_STANDALONE
    ASIO_DISABLE_VISIBILITY
  PRIVATE
    ECAL_CORE_EXPORTS
    $<$<BOOL:${ECAL_HAS_CLOCKLOCK_MUTEX}>:ECAL_HAS_CLOCKLOCK_MUTEX>
    $<$<BOOL:${ECAL_HAS_ROBUST_MUTEX}>:ECAL_HAS_ROBUST_MUTEX>
    $<$<BOOL:${ECAL_USE_CLOCKLOCK_MUTEX}>:ECAL_USE_CLOCKLOCK_MUTEX>
    ECAL_NO_DEPRECATION_WARNINGS
  INTERFACE
    ECAL_CORE_IMPORTS
)

add_compile_options(
                # GCC 4.2+ automatically assumes that signed overflows do
                # not occur in signed arithmetics, whereas we are not
                # sure that they will not happen. It furthermore complains
                # about its own optimized code in some places.
                "-fno-strict-overflow"

                # -flifetime-dse=2 (default since GCC 6) doesn't play
                # well with our custom pool item allocator
                "$<$<BOOL:${LIFETIME_DSE_FOUND}>:-flifetime-dse=1>"

                # We have a fight between clang wanting std::move() and gcc not wanting it
                # and of course they both warn when the other compiler is happy
                "$<$<COMPILE_LANGUAGE:CXX>:-Wno-redundant-move>"
            )

target_compile_definitions(
	${PROJECT_NAME}
	PRIVATE
	"$<$<BOOL:${TRACY_SUPPORT}>:TRACY_SUPPORT>"
)

add_executable(supernova
    server/main.cpp
    ${supernova_headers}

    # these files contain code only used in main()
    ${CMAKE_SOURCE_DIR}/common/SC_ServerBootDelayWarning.cpp
    $<$<BOOL:${APPLE}>: ${CMAKE_SOURCE_DIR}/common/SC_AppleEventLoop.mm >
    )

target_compile_definitions(${target} PRIVATE
        # Somewhat speed up Catch2 compile times
        CATCH_CONFIG_FAST_COMPILE
        # Let libc++ be stricter about includes
        _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
        # Enable assertions for more thorough tests
        _GLIBCXX_ASSERTIONS
        _LIBCPP_ENABLE_ASSERTIONS=1
        CPPSORT_ENABLE_ASSERTIONS
        # We test deprecated code but we don't want it to warn
        CPPSORT_DISABLE_DEPRECATION_WARNINGS
        # Conditionally turn some tests into static assertions
        $<$<NOT:$<BOOL:${CPPSORT_STATIC_TESTS}>>:CATCH_CONFIG_RUNTIME_STATIC_REQUIRE>
    )

target_link_libraries(tile 
					$<$<BOOL:${CMAKE_CUDA_COMPILER}>:gpu_kernels>
					cpu_kernels 
					qt_helper)

target_compile_definitions(MaaCore PRIVATE ASST_WITH_EMULATOR_EXTRAS=$<BOOL:${WITH_EMULATOR_EXTRAS}>)

target_compile_options(gmock_link_test PRIVATE $<$<BOOL:${MSVC}>:/wd4996>)

add_compile_definitions (BOOST_PROGRAM_OPTIONS_DYN_LINK
	$<$<BOOL:${WITH_DBUS_LOADERS}>:WITH_DBUS_LOADERS>
	$<$<BOOL:${WITH_QWT}>:WITH_QWT>
	$<$<BOOL:${X11_FOUND}>:HAVE_X11>
	)

install(FILES "$<TARGET_PROPERTY:${__target},ARCHIVE_OUTPUT_DIRECTORY>/$<CONFIG>/$<IF:$<BOOL:$<TARGET_PROPERTY:${__target},COMPILE_PDB_NAME_RELEASE>>,$<TARGET_PROPERTY:${__target},COMPILE_PDB_NAME_RELEASE>,$<TARGET_PROPERTY:${__target},COMPILE_PDB_NAME>>.pdb"
                DESTINATION "${__dst}" CONFIGURATIONS Release
                COMPONENT ${__pdb_install_component} OPTIONAL ${__pdb_exclude_from_all})

set_source_files_properties( "${CMAKE_CURRENT_SOURCE_DIR}/core/plugin/PluginManager.cpp"
    PROPERTIES
     COMPILE_DEFINITIONS
      "CMAKE_GENERATOR_IS_MULTI_CONFIG=$<BOOL:${CMAKE_GENERATOR_IS_MULTI_CONFIG}>;CMAKE_GENERATOR_CONFIGURATION=\"$<CONFIG>\""
)

target_compile_definitions(plugin
  PRIVATE
    $<$<BOOL:${LIBDL_FOUND}>:HAVE_DLFCN_H>
  )

ExternalProject_Add(${COMPONENT_NAME}
  PREFIX ${COMPONENT_NAME}
  DOWNLOAD_COMMAND ""
  STAMP_DIR ${COMPONENT_NAME}/stamp
  SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../..
  BINARY_DIR ${COMPONENT_NAME}/build
  LIST_SEPARATOR | # Use the alternate list separator
  CMAKE_ARGS
    -DCMAKE_PREFIX_PATH=${CMAKE_PREFIX_PATH}
    -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
    -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
    -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
    -DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}
    -DCMAKE_INSTALL_PREFIX:PATH=${COMPONENT_PATH}
    -DCMAKE_INSTALL_INCLUDEDIR=${CMAKE_INSTALL_INCLUDEDIR}
    -DCMAKE_INSTALL_LIBDIR=${CMAKE_INSTALL_LIBDIR}
    -DCMAKE_INSTALL_DOCDIR=${CMAKE_INSTALL_DOCDIR}
    -DCMAKE_INSTALL_BINDIR=${CMAKE_INSTALL_BINDIR}
    -DOSPRAY_ENABLE_APPS=${BUILD_OSPRAY_APPS}
    -DOSPRAY_APPS_ENABLE_GLM=${BUILD_OSPRAY_GLM}
    -DOSPRAY_BUILD_ISA=ALL
    -DOSPRAY_ENABLE_VOLUMES=${BUILD_OPENVKL}
    -DOSPRAY_MODULE_BILINEAR_PATCH=${BUILD_OSPRAY_CI_EXTRAS}
    -DOSPRAY_MODULE_DENOISER=${BUILD_OIDN}
    -DOSPRAY_INSTALL_DEPENDENCIES=${INSTALL_DEPENDENCIES}
    -DOSPRAY_STRICT_BUILD=${BUILD_OSPRAY_CI_EXTRAS}
    -DOSPRAY_WARN_AS_ERRORS=${BUILD_OSPRAY_CI_EXTRAS}
    -DOSPRAY_MODULE_MPI=${BUILD_OSPRAY_MODULE_MPI}
    -DOSPRAY_MODULE_GPU=${BUILD_GPU_SUPPORT}
    -DOSPRAY_MODULE_MULTIDEVICE=${BUILD_OSPRAY_MODULE_MULTIDEVICE}
    $<$<BOOL:${DOWNLOAD_TBB}>:-DRKCOMMON_TBB_ROOT=${TBB_PATH}>
    $<$<BOOL:${DOWNLOAD_ISPC}>:-DISPC_EXECUTABLE=${ISPC_PATH}>
    -DCMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES}
    -DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET}
    -DOSPRAY_MODULE_PATH=${CMAKE_CURRENT_BINARY_DIR} # FIXME WA for OSPRay to build with GNU-style options
  BUILD_COMMAND ${DEFAULT_BUILD_COMMAND}
  BUILD_ALWAYS OFF
)

add_compile_definitions($<$<BOOL:${HAVE_CLZ}>:HAVE_CLZ>)

set_property(
  SOURCE
  pqVRDockPanel.cxx
  pqVRCollaborationWidget.cxx
  APPEND PROPERTY
    COMPILE_DEFINITIONS "CAVEINTERACTION_HAS_COLLABORATION=$<BOOL:${VTK_ENABLE_VR_COLLABORATION}>")

target_compile_definitions(
    DataFrame
    PRIVATE $<$<BOOL:${HMDF_HAVE_CLOCK_GETTIME}>:HMDF_HAVE_CLOCK_GETTIME>
    PUBLIC $<$<CXX_COMPILER_ID:MSVC>:_USE_MATH_DEFINES>
)

target_compile_options(${ADD_SYCL_ARGS_TARGET} PUBLIC
    ${TRISYCL_COMPILE_OPTIONS}
    $<$<BOOL:${TRISYCL_OPENMP}>:${OpenMP_CXX_FLAGS}>)

target_compile_definitions(${TARGET} PUBLIC -DTINT_BUILD_GLSL_WRITER=$<BOOL:${TINT_BUILD_GLSL_WRITER}>)

install(
      CODE "
      include(\"${CMAKE_CURRENT_FUNCTION_LIST_FILE}\")
      codesign_files_macos(
        FILES \"\${CMAKE_INSTALL_PREFIX}/${DESTINATION}/$<IF:$<BOOL:$<TARGET_PROPERTY:${TARGET_NAME},MACOSX_BUNDLE>>,$<TARGET_BUNDLE_DIR_NAME:${TARGET_NAME}>,$<TARGET_FILE_NAME:${TARGET_NAME}>>\"
        SIGNING_IDENTITY \"${CPACK_CODESIGNING_DEVELOPPER_ID_APPLICATION}\"
        IDENTIFIER \"${CPACK_CODESIGNING_MACOS_IDENTIFIER}.${TARGET_NAME}\"
        FORCE VERBOSE $<$<BOOL:$<TARGET_PROPERTY:${TARGET_NAME},MACOSX_BUNDLE>>:DEEP>
        )
    "
      COMPONENT ${COMPONENT}
    )

target_compile_definitions(resipares PUBLIC $<$<BOOL:HAVE_ARPA_NAMESER_H>:HAVE_ARPA_NAMESER_H>)

target_compile_options(
    mbgl-compiler-options
    INTERFACE
        $<$<BOOL:${MLN_WITH_COVERAGE}>:--coverage>
        $<$<BOOL:${MLN_WITH_SANITIZER}>:-DSANITIZE>
        $<$<BOOL:${MLN_WITH_SANITIZER}>:-fno-omit-frame-pointer>
        $<$<BOOL:${MLN_WITH_SANITIZER}>:-fno-optimize-sibling-calls>
        $<$<STREQUAL:${MLN_WITH_SANITIZER},address>:-fsanitize=address>
        $<$<STREQUAL:${MLN_WITH_SANITIZER},thread>:-fsanitize=thread>
        $<$<STREQUAL:${MLN_WITH_SANITIZER},undefined>:-fsanitize=implicit-conversion,
        -fsanitize-blacklist=${UBSAN_BLACKLIST}>
        $<$<STREQUAL:${MLN_WITH_SANITIZER},undefined>:-fsanitize=undefined,
        -fsanitize-blacklist=${UBSAN_BLACKLIST}>
        $<$<STREQUAL:${MLN_WITH_SANITIZER},undefined>:-fsanitize=unsigned-integer-overflow,
        -fsanitize-blacklist=${UBSAN_BLACKLIST}>
        $<$<STREQUAL:${MLN_WITH_SANITIZER},undefined>:-fsanitize=nullability,
        -fsanitize-blacklist=${UBSAN_BLACKLIST}>
        $<$<STREQUAL:${MLN_WITH_SANITIZER},undefined>:-fsanitize=float-divide-by-zero,
        -fsanitize-blacklist=${UBSAN_BLACKLIST}>
        $<$<PLATFORM_ID:iOS>:-fembed-bitcode>
        $<$<AND:$<OR:$<COMPILE_LANGUAGE:CXX>,$<COMPILE_LANGUAGE:OBJCXX>>,$<NOT:$<OR:$<BOOL:${MLN_WITH_RTTI}>,$<CXX_COMPILER_ID:MSVC>>>>:-fno-rtti>
        $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<NOT:$<PLATFORM_ID:Windows>>>:-Wall>
        $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<NOT:$<PLATFORM_ID:Windows>>>:-Wshadow>
        $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<NOT:$<PLATFORM_ID:Windows>>>:-Wextra>
        $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<NOT:$<PLATFORM_ID:Windows>>,$<BOOL:${MLN_WITH_WERROR}>>:-Werror>
        $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<PLATFORM_ID:Android>>:-Wno-error=tautological-constant-compare>
        $<$<CXX_COMPILER_ID:GNU>:-Wno-error=maybe-uninitialized>
        $<$<CXX_COMPILER_ID:GNU>:-Wno-error=return-type>
        $<$<CXX_COMPILER_ID:GNU>:-Wno-error=unknown-pragmas>
        $<$<CXX_COMPILER_ID:GNU>:-Wno-error=pragmas>
        $<$<CXX_COMPILER_ID:GNU>:-Wno-psabi>
        $<$<CXX_COMPILER_ID:AppleClang>:-Wno-unknown-warning-option>
        $<$<AND:$<CXX_COMPILER_ID:AppleClang>,$<NOT:$<BOOL:${MLN_WITH_QT}>>>:-Wno-error=deprecated-declarations>
        $<$<AND:$<CXX_COMPILER_ID:AppleClang>,$<NOT:$<BOOL:${MLN_WITH_QT}>>>:-Wno-error=unused-parameter>
        $<$<AND:$<CXX_COMPILER_ID:AppleClang>,$<NOT:$<BOOL:${MLN_WITH_QT}>>>:-Wno-error=unused-property-ivar>
        $<$<CXX_COMPILER_ID:MSVC>:/utf-8>
        $<$<CXX_COMPILER_ID:MSVC>:/WX>      # all warnings as errors
        $<$<CXX_COMPILER_ID:MSVC>:/EHsc>    # exceptions
        $<$<CXX_COMPILER_ID:MSVC>:/wd4068>  # pragma
        $<$<CXX_COMPILER_ID:MSVC>:/D_USE_MATH_DEFINES>
        $<$<AND:$<NOT:$<CXX_COMPILER_ID:MSVC>>,$<PLATFORM_ID:Windows>>:-D_USE_MATH_DEFINES>
        $<$<CXX_COMPILER_ID:MSVC>:/D_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS>
        $<$<CXX_COMPILER_ID:MSVC>:/D_CRT_SECURE_NO_WARNINGS>
)

add_custom_command(
                TARGET
                    ${TARGET}
                PRE_BUILD
                COMMAND
                    ${CLANG_FORMAT}
                ARGS
                    $<$<BOOL:${GPA_REQUIRE_CLEAN_LINT}>:-Werror>
                    $<$<BOOL:${GPA_APPLY_LINT_FIXES}>:-i>
                    ${CLANG_FORMAT_SOURCES}
                WORKING_DIRECTORY
                    ${CMAKE_PROJECT_DIR}
                COMMAND_EXPAND_LISTS
                COMMENT
                    "Running clang format on sources for ${TARGET}..."
            )

add_custom_target(
        ${check_target}
        COMMAND
            ${clang_tidy_EXECUTABLE}
                -p\t${PROJECT_BINARY_DIR}
                ${ARGN}
                -checks=*
                "$<$<NOT:$<BOOL:${CMAKE_EXPORT_COMPILE_COMMANDS}>>:--\t$<$<BOOL:${includes}>:-I$<JOIN:${includes},\t-I>>>"
        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
    )

target_link_options(${PROJECT_NAME} PRIVATE "/guard:cf" $<$<BOOL:${CROSSSIGNCERT}>:/INTEGRITYCHECK>)

target_compile_definitions(${PROJECT_NAME}
  PRIVATE
    HAVE_FREETYPE=1
    # TODO: Enable later if necessary, and sync with xcode/harfbuzz project.
    #HAVE_ICU
    #$<$<BOOL:${APPLE}>:HAVE_CORETEXT>
    HAVE_ATEXIT
    HAVE_GETPAGESIZE
    HAVE_MPROTECT
    HAVE_SYSCONF
)

target_compile_definitions(
        ${_asio_grpc_name} PUBLIC "ASIO_GRPC_TEST_CPP_VERSION=\"${_test_suite_name} C++${_asio_grpc_cxx_standard}\""
                                  $<$<BOOL:${ASIO_GRPC_HAS_STD_PMR}>:AGRPC_TEST_HAS_STD_PMR>)

target_compile_definitions(
	${PROJECT_NAME}
	PRIVATE
		ARCHITECTURE_X64
		GLFW_INCLUDE_NONE
		CLIP_ENABLE_IMAGE
		$<$<PLATFORM_ID:Linux>:HAVE_PNG_H>
		$<$<CONFIG:Debug>:CONFIG_DEBUG>
		$<$<CONFIG:Release>:CONFIG_RELEASE>
		$<$<CXX_COMPILER_ID:MSVC>:_CRT_SECURE_NO_DEPRECATE>

		$<$<PLATFORM_ID:Windows>:PLATFORM_WINDOWS>
		$<$<PLATFORM_ID:Linux>:PLATFORM_LINUX>

		$<$<BOOL:${PACKAGE_PORTABLE}>:PACKAGE_PORTABLE>
		$<$<BOOL:${PACKAGE_DEV}>:PACKAGE_DEV>
		$<$<AND:$<PLATFORM_ID:Linux>,$<BOOL:${PACKAGE_SNAP}>>:PACKAGE_SNAP>
		$<$<AND:$<PLATFORM_ID:Linux>,$<BOOL:${PACKAGE_DEB}>>:PACKAGE_DEB>
		$<$<AND:$<PLATFORM_ID:Linux>,$<BOOL:${PACKAGE_NIX}>>:PACKAGE_NIX>

		# These shouldn't actually be necessary as there are no direct Windows API calls
		# in TacentView (they are abstracted away by the Tacent libraries). But just in case
		# anything in the viewer were to call an OS-level function, these enable the UTF-16
		# versions if the TACENT_UTF16_API_CALLS option is set.
		$<$<AND:$<PLATFORM_ID:Windows>,$<BOOL:${TACENT_UTF16_API_CALLS}>>:UNICODE>	# C++	UFF-16
		$<$<AND:$<PLATFORM_ID:Windows>,$<BOOL:${TACENT_UTF16_API_CALLS}>>:_UNICODE>	# C		UTF-16
		$<$<AND:$<PLATFORM_ID:Windows>,$<BOOL:${TACENT_UTF16_API_CALLS}>>:TACENT_UTF16_API_CALLS>
)

target_compile_options(${target_name} ${COMPILE_OPTIONS_VISIBILITY}
            # General warnings for Clang, AppleClang, and GNU, but NOT on Windows
            $<$<AND:$<OR:$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:AppleClang>,$<CXX_COMPILER_ID:GNU>>,$<NOT:$<PLATFORM_ID:Windows>>>:
            -Wall -Wextra -pedantic -Werror -Wredundant-decls -Wfloat-equal
            >

            # GCC-specific hardening and security flags
            $<$<AND:$<CXX_COMPILER_ID:GNU>,$<BOOL:${QUILL_ENABLE_GCC_HARDENING}>>:
            -fstack-protector-strong
            -fstack-clash-protection
            -Wformat
            -Werror=format-security
            -fcf-protection
            -Wdate-time
            -D_FORTIFY_SOURCE=2
            >

            # GCC >= 7.1 specific: suppress PSABI warning
            $<$<AND:$<CXX_COMPILER_ID:GNU>,$<VERSION_GREATER_EQUAL:$<CXX_COMPILER_VERSION>,7.1>>:
            -Wno-psabi
            >

            # Clang specific options, but NOT on Windows
            $<$<AND:$<OR:$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:AppleClang>>,$<NOT:$<PLATFORM_ID:Windows>>>:
            -Wimplicit-int-float-conversion -Wdocumentation
            >

            # Disable C++20 extension warnings for Clang > 17, but NOT on Windows
            $<$<AND:$<CXX_COMPILER_ID:Clang>,$<VERSION_GREATER:$<CXX_COMPILER_VERSION>,17>,$<NOT:$<PLATFORM_ID:Windows>>>:
            -Wno-c++20-extensions
            >

            # Disable specific warning for Clang and AppleClang, but NOT on Windows
            $<$<AND:$<OR:$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:AppleClang>>,$<NOT:$<PLATFORM_ID:Windows>>>:
            -Wno-gnu-zero-variadic-macro-arguments
            >

            # Windows-specific options
            $<$<PLATFORM_ID:Windows>:$<$<OR:$<CXX_COMPILER_ID:MSVC>,$<CXX_COMPILER_ID:Clang>>:/bigobj /WX /W4 /wd4324 /wd4996>>
    )

add_compile_definitions( $<$<BOOL:${KICAD_SCRIPTING_WXPYTHON}>:KICAD_SCRIPTING_WXPYTHON> )

target_compile_options(${proj} PRIVATE $<$<BOOL:${LIBNYQUIST_ENABLE_AVX}>:/arch:AVX>  /Zi )

target_compile_options(${PROJECT_NAME} INTERFACE
    $<$<OR:$<BOOL:${CLANG}>,$<CXX_COMPILER_ID:GNU>>:
        -fno-common;
        -fstrict-overflow;
        -ftrapv;
        -pedantic-errors;
        -Wall;
        -Wcast-align;
        -Wdouble-promotion;
        -Wextra;
        -Wformat=2;
        -Wmissing-declarations;
        -Wnon-virtual-dtor;
        -Wnull-dereference;
        -Wold-style-cast;
        -Woverloaded-virtual;
        -Wshadow;
        -Wsign-compare;
        -Wundef;
    >
    $<$<CXX_COMPILER_ID:GNU>:
        -Wduplicated-cond;
        -Wlogical-op;
    >
    $<$<BOOL:${CLANG}>:
        -Wmissing-variable-declarations;
        -Wno-gnu-zero-variadic-macro-arguments; # Required for gtest 1.10.
    >
    $<$<OR:$<BOOL:${CLANGCL}>,$<CXX_COMPILER_ID:MSVC>>:
        /permissive-;
        /W4;
        /w14254; # 'operator': conversion from 'type1:field_bits' to
                 # 'type2:field_bits', possible loss of data
        /w14263; # 'function': member function does not override any base class
                 # virtual member function
        /w14265; # 'classname': class has virtual functions, but destructor is not
                 # virtual instances of this class may not be destructed correctly
        /w14287; # 'operator': unsigned/negative constant mismatch
        /w14289; # nonstandard extension used: 'variable': loop control variable
                 # declared in the for-loop is used outside the for-loop scope
        /w14296; # 'operator': expression is always 'boolean_value'
        /w14311; # 'variable': pointer truncation from 'type1' to 'type2'
        /w14545; # expression before comma evaluates to a function which is missing
                 # an argument list
        /w14546; # function call before comma missing argument list
        /w14547; # 'operator': operator before comma has no effect; expected
                 # operator with side-effect
        /w14549; # 'operator': operator before comma has no effect; did you intend
                 # 'operator'?
        /w14555; # expression has no effect; expected expression with side- effect
        /w14619; # pragma warning: there is no warning number 'number'
        /w14640; # Enable warning on thread un-safe static member initialization
        /w14826; # Conversion from 'type1' to 'type_2' is sign-extended. This may
                 # cause unexpected runtime behavior.
        /w14928; # illegal copy-initialization; more than one user-defined
                 # conversion has been implicitly applied
        /wd4244; # 'argument': conversion from 'int' to 'unsigned char', possible
                 # loss of data # This one is sort of required for gtest.
        /WX;
    >
    $<$<BOOL:${STRICT_OPTIONS}>:
        -Werror;
    >
    $<$<BOOL:${COMPILER_SUPPORTS_WARNING_WEAK_VTABLES}>:
        -Wweak-vtables; # https://llvm.org/docs/CodingStandards.html#provide-a-virtual-method-anchor-for-classes-in-headers
    >
    $<$<BOOL:${COMPILER_SUPPORTS_WDATE_TIME}>:
        -Wdate-time; # avoid timestamps in binary for reproducible builds, not added until GCC 4.9
    >
    $<$<AND:$<NOT:$<BOOL:${WIN32}>>,$<NOT:$<BOOL:${HAIKU}>>>:
        -Wstack-protector;
    >
)

target_link_libraries(strawberry_lib PUBLIC
  ${CMAKE_THREAD_LIBS_INIT}
  $<$<BOOL:${HAVE_BACKTRACE}>:${Backtrace_LIBRARIES}>
  PkgConfig::GLIB
  PkgConfig::GOBJECT
  PkgConfig::SQLITE
  PkgConfig::GSTREAMER
  PkgConfig::GSTREAMER_BASE
  PkgConfig::GSTREAMER_AUDIO
  PkgConfig::GSTREAMER_APP
  PkgConfig::GSTREAMER_TAG
  PkgConfig::GSTREAMER_PBUTILS
  ${TAGLIB_LIBRARIES}
  Qt${QT_VERSION_MAJOR}::Core
  Qt${QT_VERSION_MAJOR}::Concurrent
  Qt${QT_VERSION_MAJOR}::Gui
  Qt${QT_VERSION_MAJOR}::Widgets
  Qt${QT_VERSION_MAJOR}::Network
  Qt${QT_VERSION_MAJOR}::Sql
  $<$<BOOL:${HAVE_DBUS}>:Qt${QT_VERSION_MAJOR}::DBus>
  $<$<BOOL:${HAVE_QPA_QPLATFORMNATIVEINTERFACE}>:Qt${QT_VERSION_MAJOR}::GuiPrivate>
  ICU::uc
  ICU::i18n
  $<$<BOOL:${HAVE_STREAMTAGREADER}>:PkgConfig::LIBSPARSEHASH>
  $<$<BOOL:${HAVE_ALSA}>:ALSA::ALSA>
  $<$<BOOL:${HAVE_PULSE}>:PkgConfig::LIBPULSE>
  $<$<BOOL:${HAVE_CHROMAPRINT}>:PkgConfig::CHROMAPRINT>
  $<$<BOOL:${HAVE_MOODBAR}>:PkgConfig::FFTW3>
  $<$<BOOL:${HAVE_EBUR128}>:PkgConfig::LIBEBUR128>
  $<$<BOOL:${HAVE_X11_GLOBALSHORTCUTS}>:X11::X11_xcb>
  $<$<BOOL:${HAVE_GIO}>:PkgConfig::GIO>
  $<$<BOOL:${HAVE_GIO_UNIX}>:PkgConfig::GIO_UNIX>
  $<$<BOOL:${HAVE_AUDIOCD}>:PkgConfig::LIBCDIO>
  $<$<BOOL:${HAVE_MTP}>:PkgConfig::LIBMTP>
  $<$<BOOL:${HAVE_GPOD}>:PkgConfig::LIBGPOD PkgConfig::GDK_PIXBUF>
  $<$<BOOL:${HAVE_QTSPARKLE}>:qtsparkle-qt${QT_VERSION_MAJOR}::qtsparkle>
  $<$<BOOL:${WIN32}>:dsound dwmapi ${GETOPT_LIBRARIES}>
  $<$<BOOL:${MSVC}>:WindowsApp>
  KDAB::kdsingleapplication
  $<$<BOOL:${HAVE_DISCORD_RPC}>:discord-rpc>
)

target_compile_options(flatc
    PRIVATE
      $<$<AND:$<BOOL:${MSVC_LIKE}>,$<CONFIG:Release>>:
        /MT
      >
  )

set_property(TARGET "${target}" PROPERTY
                ${property} "$<BOOL:$<TARGET_PROPERTY:${arg_PARENT_TARGET},${property}>>")

target_link_libraries(otbr-sdp-proxy PRIVATE
    $<$<BOOL:${OTBR_MDNS}>:otbr-mdns>
    otbr-common
)

set_source_files_properties(
    scene/surface/material/Material.cpp
    PROPERTIES COMPILE_DEFINITIONS $<$<BOOL:${VISRTX_USE_MDL_FOR_PHYSICALLY_BASED}>:USE_MDL_FOR_PHYSICALLY_BASED>
  )

target_compile_options (
            cuda_build_configuration
            INTERFACE
                "$<$<COMPILE_LANGUAGE:CUDA>:--std=c++17;--use_fast_math;--expt-relaxed-constexpr;--extended-lambda;--forward-unknown-to-host-compiler>"
                # The "$<NOT:$<BOOL:$<TARGET_PROPERTY:CUDA_PTX_COMPILATION>>>" part is to not add debugging symbols when generating PTX files for OptiX; see https://github.com/mmp/pbrt-v4/issues/69#issuecomment-715499748.
                "$<$<COMPILE_LANGUAGE:CUDA>:$<IF:$<AND:$<CONFIG:Debug>,$<NOT:$<BOOL:$<TARGET_PROPERTY:CUDA_PTX_COMPILATION>>>>,-G;-g,-lineinfo;-maxrregcount;128>>"
        )

add_test(NAME sample_additive_path COMMAND sample_additive "--skeleton=media/skeleton.ozz" "--animation=media/animation_base.ozz" "--splay_animation=media/animation_splay_additive.ozz" "--curl_animation=media/animation_curl_additive.ozz" "--max_idle_loops=${ozz_sample_testing_loops}" $<$<BOOL:${ozz_run_tests_headless}>:--norender>)

target_compile_definitions(Diligent-PublicBuildSettings
INTERFACE
    D3D11_SUPPORTED=$<BOOL:${D3D11_SUPPORTED}>
    D3D12_SUPPORTED=$<BOOL:${D3D12_SUPPORTED}>
    GL_SUPPORTED=$<BOOL:${GL_SUPPORTED}>
    GLES_SUPPORTED=$<BOOL:${GLES_SUPPORTED}>
    VULKAN_SUPPORTED=$<BOOL:${VULKAN_SUPPORTED}>
    METAL_SUPPORTED=$<BOOL:${METAL_SUPPORTED}>
    WEBGPU_SUPPORTED=$<BOOL:${WEBGPU_SUPPORTED}>
)

add_compile_options("$<$<BOOL:${DEVILUTIONX_PROFILE_GENERATE}>:-fprofile-generate>")

target_include_directories (${HDF5_HL_CPP_LIB_TARGET}
      PRIVATE "${HDF5_SRC_INCLUDE_DIRS};${HDF5_SRC_BINARY_DIR};$<$<BOOL:${HDF5_ENABLE_PARALLEL}>:${MPI_C_INCLUDE_DIRS}>"
      INTERFACE "$<INSTALL_INTERFACE:$<INSTALL_PREFIX>/include>"
  )

target_compile_options(PEGParser PUBLIC "$<$<BOOL:${MSVC}>:/permissive->")

target_compile_definitions(jive-demo
                           INTERFACE JIVE_GUI_ITEMS_HAVE_STYLE_SHEETS=1
                                     JUCE_APPLICATION_NAME="$<TARGET_PROPERTY:jive-demo,JUCE_PRODUCT_NAME>"
                                     JUCE_APPLICATION_VERSION="$<TARGET_PROPERTY:jive-demo,JUCE_VERSION>"
                                     JUCE_VST3_CAN_REPLACE_VST2=0
                                     JIVE_ENABLE_MELATONIN_INSPECTOR=$<BOOL:${JIVE_ENABLE_MELATONIN_INSPECTOR}>
)

add_library(
  v8_initializers STATIC
  $<${is-arm64}:v8/src/builtins/arm64/builtins-arm64.cc>
  $<${is-arm}:v8/src/builtins/arm/builtins-arm.cc>
  $<${is-ia32}:v8/src/builtins/ia32/builtins-ia32.cc>
  $<${is-mips64}:v8/src/builtins/mips64/builtins-mips64.cc>
  $<${is-mips}:v8/src/builtins/mips/builtins-mips.cc>
  $<${is-ppc}:v8/src/builtins/ppc/builtins-ppc.cc>
  $<${is-s390}:v8/src/builtins/s390/builtins-s390.cc>
  $<${is-x64}:v8/src/builtins/x64/builtins-x64.cc>
  $<$<BOOL:${V8_ENABLE_I18N}>:v8/src/builtins/builtins-intl-gen.cc>
  v8/src/builtins/builtins-array-gen.cc
  v8/src/builtins/builtins-async-function-gen.cc
  v8/src/builtins/builtins-async-gen.cc
  v8/src/builtins/builtins-async-generator-gen.cc
  v8/src/builtins/builtins-async-iterator-gen.cc
  v8/src/builtins/builtins-bigint-gen.cc
  v8/src/builtins/builtins-call-gen.cc
  v8/src/builtins/builtins-collections-gen.cc
  v8/src/builtins/builtins-constructor-gen.cc
  v8/src/builtins/builtins-conversion-gen.cc
  v8/src/builtins/builtins-date-gen.cc
  v8/src/builtins/builtins-generator-gen.cc
  v8/src/builtins/builtins-global-gen.cc
  v8/src/builtins/builtins-handler-gen.cc
  v8/src/builtins/builtins-ic-gen.cc
  v8/src/builtins/builtins-internal-gen.cc
  v8/src/builtins/builtins-interpreter-gen.cc
  v8/src/builtins/builtins-iterator-gen.cc
  v8/src/builtins/builtins-lazy-gen.cc
  v8/src/builtins/builtins-microtask-queue-gen.cc
  v8/src/builtins/builtins-number-gen.cc
  v8/src/builtins/builtins-object-gen.cc
  v8/src/builtins/builtins-promise-gen.cc
  v8/src/builtins/builtins-proxy-gen.cc
  v8/src/builtins/builtins-regexp-gen.cc
  v8/src/builtins/builtins-sharedarraybuffer-gen.cc
  v8/src/builtins/builtins-string-gen.cc
  v8/src/builtins/builtins-typed-array-gen.cc
  v8/src/builtins/builtins-wasm-gen.cc
  v8/src/builtins/growable-fixed-array-gen.cc
  v8/src/builtins/setup-builtins-internal.cc
  v8/src/codegen/code-stub-assembler.cc
  v8/src/heap/setup-heap-internal.cc
  v8/src/ic/accessor-assembler.cc
  v8/src/ic/binary-op-assembler.cc
  v8/src/ic/keyed-store-generic.cc
  v8/src/ic/unary-op-assembler.cc
  v8/src/interpreter/interpreter-assembler.cc
  v8/src/interpreter/interpreter-generator.cc
  v8/src/interpreter/interpreter-intrinsics-generator.cc
)

ExternalProject_Add(
    FREETYPE_Local
    PREFIX ${CMAKE_BINARY_DIR}/external/FreeType
    URL ${harfbuzzArchive}
    URL_HASH SHA256=${harfbuzzArchive_hash}
    CMAKE_ARGS
        "-DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}"
        "-DCMAKE_INSTALL_PREFIX=${DEPENDENCIES_INSTALL_DIR}"
        "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
        "-DCMAKE_POSITION_INDEPENDENT_CODE=ON"
        "-DCMAKE_DEBUG_POSTFIX=${PGE_LIBS_DEBUG_SUFFIX}"
        ${ANDROID_CMAKE_FLAGS}
        -DFT_WITH_ZLIB=ON -DFT_WITH_BZIP2=OFF -DFT_WITH_PNG=ON -DFT_WITH_HARFBUZZ=OFF
        $<$<BOOL:APPLE>:-DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET}>
        $<$<BOOL:APPLE>:"-DCMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES}">
)

target_compile_definitions(WideInteger::WideInteger
    INTERFACE
        $<$<BOOL:${_HAVE_INT128}>:WIDE_INTEGER_HAS_LIMB_TYPE_UINT64>
)

target_compile_definitions(${target} PUBLIC $<IF:$<BOOL:${BUILD_SHARED_LIBS}>,BOOST_URL_DYN_LINK=1,BOOST_URL_STATIC_LINK=1>)

target_compile_definitions(pull
  PRIVATE
    $<$<BOOL:${ENABLE_COMPRESSION}>:HAVE_ZLIB>
)

target_compile_definitions(yaml
  PRIVATE HAVE_CONFIG_H
  PUBLIC
    $<$<NOT:$<BOOL:${BUILD_SHARED_LIBS}>>:YAML_DECLARE_STATIC>
    $<$<BOOL:${MSVC}>:_CRT_SECURE_NO_WARNINGS>
  )

add_link_options(
  "$<$<NOT:$<CONFIG:Debug>>:${GC_SECTIONS_LINK_OPTS}>"
  # asan
  "$<$<BOOL:${QCM_USE_ASAN}>:-fsanitize=address>"
  "$<$<BOOL:${QCM_USE_ASAN}>:-fsanitize=undefined>"
  "$<$<BOOL:${QCM_USE_ASAN}>:-fsanitize-recover=address>")

add_compile_definitions($<$<BOOL:${WIN32}>:_CRT_SECURE_NO_WARNINGS>)

target_compile_definitions(TestCommonRead_f PRIVATE
    $<$<BOOL:${ADIOS2_HAVE_FORTRAN_F03_ARGS}>:ADIOS2_HAVE_FORTRAN_F03_ARGS>
    $<$<BOOL:${ADIOS2_HAVE_FORTRAN_GNU_ARGS}>:ADIOS2_HAVE_FORTRAN_GNU_ARGS>
  )

target_compile_definitions(operon_operon PUBLIC
    "$<$<BOOL:${USE_SINGLE_PRECISION}>:USE_SINGLE_PRECISION>"
    "$<$<BOOL:${HAVE_CERES}>:HAVE_CERES>"
    )

target_link_libraries(
        ${libName}
        PUBLIC
        $<$<BOOL:${CMAKE_USE_PTHREADS_INIT}>:Threads::Threads>)

target_compile_definitions(
    tinyxml2
    PUBLIC $<$<CONFIG:Debug>:TINYXML2_DEBUG>
    INTERFACE $<$<BOOL:${BUILD_SHARED_LIBS}>:TINYXML2_IMPORT>
    PRIVATE $<$<CXX_COMPILER_ID:MSVC>:_CRT_SECURE_NO_WARNINGS>
    PUBLIC _FILE_OFFSET_BITS=64
)

add_compile_definitions(HANNK_BUILD_TFLITE=$<BOOL:${HANNK_BUILD_TFLITE}>)

target_compile_definitions(content_filter PRIVATE
    $<$<AND:$<NOT:$<BOOL:${WIN32}>>,$<STREQUAL:"${CMAKE_BUILD_TYPE}","Debug">>:__DEBUG>
    $<$<BOOL:${INTERNAL_DEBUG}>:__INTERNALDEBUG> # Internal debug activated.
)

target_compile_definitions(tools_test PRIVATE
      $<$<AND:$<BOOL:${WITH_UNIVERSAL_BINARY}>,$<BOOL:${WITH_TOOLS}>>:DWARFS_HAVE_UNIVERSAL_BINARY>
      $<$<BOOL:${WITH_TOOLS}>:DWARFS_WITH_TOOLS>
      $<$<BOOL:${WITH_FUSE_DRIVER}>:DWARFS_WITH_FUSE_DRIVER>
      $<$<BOOL:${MKDWARFS_EXE}>:MKDWARFS_BINARY=\"${MKDWARFS_EXE}\">
      $<$<BOOL:${DWARFSCK_EXE}>:DWARFSCK_BINARY=\"${DWARFSCK_EXE}\">
      $<$<BOOL:${DWARFSEXTRACT_EXE}>:DWARFSEXTRACT_BINARY=\"${DWARFSEXTRACT_EXE}\">
      $<$<BOOL:${CMAKE_CROSSCOMPILING}>:DWARFS_CROSSCOMPILING_EMULATOR=\"${CMAKE_CROSSCOMPILING_EMULATOR}\">
    )

add_custom_command(TARGET openclonk
		POST_BUILD COMMAND
		"${CMAKE_CURRENT_SOURCE_DIR}/tools/osx_bundle_libs"
		"$<$<BOOL:${CMAKE_SYSROOT}>:--sysroot=${CMAKE_SYSROOT}>"
		"$<TARGET_FILE:openclonk>"
	)

add_custom_command(TARGET ${depending_target} POST_BUILD COMMAND
            "$<$<BOOL:${required_dll_files}>:${CMAKE_COMMAND};-E;copy_if_different;${required_dll_files};$<TARGET_FILE_DIR:${depending_target}>>"
            COMMAND_EXPAND_LISTS
            VERBATIM
        )

add_custom_target(pkgbuild DEPENDS digidocpp $<TARGET_NAME_IF_EXISTS:digidoc-tool>
        COMMAND DESTDIR=install ${CMAKE_COMMAND} --install .
        COMMAND pkgbuild --root install "$<$<BOOL:${SIGNCERT}>:--sign;${SIGNCERT}>"
            ${CMAKE_BINARY_DIR}/libdigidocpp_${VERSION}$ENV{VER_SUFFIX}.pkg
        COMMAND_EXPAND_LISTS
    )

add_compile_definitions(FO_ENABLE_3D=$<BOOL:${FO_ENABLE_3D}>)

target_compile_options(${targetName} PUBLIC
    ${TRISYCL_COMPILE_OPTIONS}
    $<$<BOOL:${TRISYCL_OPENMP}>:${OpenMP_CXX_FLAGS}>)

add_compile_options ($<$<BOOL:${HAVE_NO_UNNAMED_TYPE_TEMPLATE_ARGS}>:-Wno-unnamed-type-template-args>)

target_include_directories(${PROJECT_NAME} BEFORE
    PUBLIC
        $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
        $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/include>
        $<INSTALL_INTERFACE:${INCLUDE_INSTALL_DIR}>
        $<TARGET_PROPERTY:fastcdr,INTERFACE_INCLUDE_DIRECTORIES>
    PRIVATE
        $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/src/cpp>
        $<$<BOOL:${UAGENT_FAST_PROFILE}>:$<TARGET_PROPERTY:fastdds,INTERFACE_INCLUDE_DIRECTORIES>>
        $<$<BOOL:${UAGENT_LOGGER_PROFILE}>:$<TARGET_PROPERTY:spdlog::spdlog,INTERFACE_INCLUDE_DIRECTORIES>>
        $<$<BOOL:${UAGENT_P2P_PROFILE}>:$<TARGET_PROPERTY:microxrcedds_client,INTERFACE_INCLUDE_DIRECTORIES>>
        $<$<BOOL:${UAGENT_P2P_PROFILE}>:$<TARGET_PROPERTY:microcdr,INTERFACE_INCLUDE_DIRECTORIES>>
    )

target_compile_definitions(${PROJECT_NAME} PRIVATE
		$<$<BOOL:${APPLE}>:GL_SILENCE_DEPRECATION>
		$<$<BOOL:${ENABLE_LOG}>:DEBUGFAST>
		$<$<BOOL:${IOS}>:TARGET_IPHONE>
		$<$<BOOL:${TARGET_MAC}>:TARGET_MAC>
		$<$<BOOL:${IOS}>:GLES>
		$<$<BOOL:${IOS}>:GLES3>
		$<$<BOOL:${IOS}>:GLES_SILENCE_DEPRECATION>
		$<$<BOOL:${MSVC}>:_CRT_NONSTDC_NO_WARNINGS>
		$<$<BOOL:${MSVC}>:_CRT_SECURE_NO_WARNINGS>
		$<$<BOOL:${MSVC}>:_WINSOCK_DEPRECATED_NO_WARNING>
		$<$<BOOL:${MSVC}>:NOMINMAX>
		$<$<BOOL:${TEST_AUTOMATION}>:TEST_AUTOMATION>
		$<$<BOOL:${WINDOWS_STORE}>:NOCRYPT>
		$<$<BOOL:${WINDOWS_STORE}>:_WIN32_WINNT=0x0A00>
		$<$<OR:$<BOOL:${MINGW}>,$<BOOL:${MSVC}>>:_USE_MATH_DEFINES>)

target_compile_definitions(glfw PRIVATE
                           "$<$<BOOL:${MINGW}>:UNICODE;WINVER=0x0501>")

ExternalProject_Add(
        DiscordPRC_Local
        PREFIX ${CMAKE_BINARY_DIR}/external/DiscordRPC
        DOWNLOAD_COMMAND ""
        SOURCE_DIR ${CMAKE_CURRENT_LIST_DIR}/../3rdparty/thextech-discord-rpc
        CMAKE_ARGS
            "-DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}"
            "-DCMAKE_INSTALL_PREFIX=${DEPENDENCIES_INSTALL_DIR}"
            "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
            "-DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}"
            "-DCMAKE_POSITION_INDEPENDENT_CODE=${FREETYPE_PIC}"
            "-DCMAKE_DEBUG_POSTFIX=${PGE_LIBS_DEBUG_SUFFIX}"
            "-DBUILD_EXAMPLES=OFF"
            ${ANDROID_CMAKE_FLAGS}
            $<$<BOOL:APPLE>:-DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET}>
            $<$<BOOL:APPLE>:-DCMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES}>
        BUILD_BYPRODUCTS
            "${libDiscordRpc_Libs}"
    )

target_compile_options(${targetName} PRIVATE $<$<BOOL:${CYGWIN}>:-Wa,-mbig-obj>)

add_compile_definitions(USE_GUIDANCE=$<BOOL:${USE_GUIDANCE}>)

target_link_libraries(NRI_VK
        PRIVATE
            NRI_Shared
            $<$<BOOL:${APPLE}>:
                ${Vulkan_LIBRARIES}
            >
    )

target_compile_options(libremidi
    ${_public}
      $<$<BOOL:${LIBREMIDI_CXX_HAS_WNO_GNU_STATEMENT}>:-Wno-gnu-statement-expression-from-macro-expansion>
      $<$<BOOL:${LIBREMIDI_CXX_HAS_WNO_C99_EXTENSIONS}>:-Wno-c99-extensions>
  )

target_compile_definitions(${HDF5_CPP_LIB_TARGET}
      PRIVATE $<$<BOOL:${HDF5_ENABLE_PARALLEL}>:MPICH_SKIP_MPICXX;MPICH_IGNORE_CXX_SEEK># Parallel/MPI, prevent spurious cpp/cxx warnings
  )

target_compile_definitions(
  flashlight
  PUBLIC
  FL_USE_ARRAYFIRE=$<BOOL:${FL_USE_ARRAYFIRE}>
  FL_USE_JIT=$<BOOL:${FL_USE_JIT}>
  FL_USE_TENSOR_STUB=$<BOOL:${FL_USE_TENSOR_STUB}>
  FL_USE_ONEDNN=$<BOOL:${FL_USE_ONEDNN}>
)

target_compile_definitions(Falcor
    PUBLIC
        $<$<CONFIG:Release>:NDEBUG>
        $<$<CONFIG:Debug>:_DEBUG>
        # Windows.
        $<$<PLATFORM_ID:Windows>:NOMINMAX>  # do not define min/max macros
        $<$<PLATFORM_ID:Windows>:UNICODE>   # force character map to unicode
        # MSVC C++ library.
        $<$<CXX_COMPILER_ID:MSVC>:_USE_MATH_DEFINES>
        $<$<CXX_COMPILER_ID:MSVC>:_SCL_SECURE_NO_WARNINGS>
        $<$<CXX_COMPILER_ID:MSVC>:_CRT_SECURE_NO_WARNINGS>
        $<$<CXX_COMPILER_ID:MSVC>:_SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING>
        $<$<CXX_COMPILER_ID:MSVC>:_SILENCE_ALL_MS_EXT_DEPRECATION_WARNINGS>
        # Clang.
        $<$<CXX_COMPILER_ID:Clang>:_MSC_EXTENSIONS> # enable MS extensions
        # Falcor feature flags.
        FALCOR_ENABLE_ASSERTS=$<BOOL:${FALCOR_ENABLE_ASSERTS_}>
        FALCOR_ENABLE_PROFILER=$<BOOL:${FALCOR_ENABLE_PROFILER}>
        FALCOR_HAS_D3D12=$<BOOL:${FALCOR_HAS_D3D12}>
        FALCOR_HAS_VULKAN=$<BOOL:${FALCOR_HAS_VULKAN}>
        FALCOR_HAS_AFTERMATH=$<BOOL:${FALCOR_HAS_AFTERMATH}>
        FALCOR_HAS_NVAPI=$<BOOL:${FALCOR_HAS_NVAPI}>
        FALCOR_HAS_CUDA=$<BOOL:${FALCOR_HAS_CUDA}>
        FALCOR_HAS_D3D12_AGILITY_SDK=$<BOOL:${FALCOR_HAS_D3D12_AGILITY_SDK}>
        # TODO: RTXDI is always available, we might want to remove the feature flag.
        FALCOR_HAS_RTXDI=1
        IMGUI_USER_CONFIG="Utils/UI/ImGuiConfig.h"
    PRIVATE
        #$<$<CONFIG:Debug>:_ITERATOR_DEBUG_LEVEL=0>
        FALCOR_PROJECT_DIR="${CMAKE_SOURCE_DIR}/"
        FALCOR_DLL
        $<$<PLATFORM_ID:Windows>:IMGUI_API=__declspec\(dllexport\)>
        $<$<PLATFORM_ID:Linux>:IMGUI_API=__attribute__\(\(visibility\("default"\)\)\)>
)

target_compile_definitions(${target}
    PRIVATE

    PUBLIC
    $<$<NOT:$<BOOL:${BUILD_SHARED_LIBS}>>:${target_id}_STATIC_DEFINE>
    ${DEFAULT_COMPILE_DEFINITIONS}

    INTERFACE
)

target_compile_options(${ADD_SYCL_ARGS_TARGET} PUBLIC
    ${TRISYCL_COMPILE_OPTIONS}
    $<$<BOOL:${TRISYCL_OPENMP}>:${OpenMP_CXX_FLAGS}>)

target_compile_definitions(
        tinyxml2
        PUBLIC $<$<CONFIG:Debug>:TINYXML2_DEBUG>
        INTERFACE $<$<BOOL:${BUILD_SHARED_LIBS}>:TINYXML2_IMPORT>
        PRIVATE $<$<CXX_COMPILER_ID:MSVC>:_CRT_SECURE_NO_WARNINGS>
)

add_compile_definitions(
    $<$<BOOL:${WIN32}>:_CRT_SECURE_NO_WARNINGS>
    $<$<BOOL:${NO_BUFFER}>:NOXFERMEM>
    $<$<BOOL:${NEWOLD_WRITE_SAMPLE}>:NEWOLD_WRITE_SAMPLE>)

target_compile_options(spdlog
      PRIVATE
        $<$<BOOL:${has_cxx_fp_model}>:-fp-model precise>)

add_compile_definitions(
    # LLVM's clang in combination with libc++
    $<$<AND:$<CONFIG:Debug>,$<BOOL:${IS_CLANG_LIBCPP}>>:_LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_DEBUG>
    # LLVM's clang or gcc in combination with libstdc++ (GNU)
    $<$<AND:$<CONFIG:Debug>,$<NOT:$<BOOL:${IS_CLANG_LIBCPP}>>>:_GLIBCXX_ASSERTIONS>
)

add_compile_options(
  -Wall
  -Wextra
  $<$<NOT:$<BOOL:${APPLE}>>:-Wdeprecated>
  -Wnull-dereference
  -Wno-unused-parameter
  -Wno-vla
)

target_link_libraries(
    BaseLib
    PUBLIC Boost::algorithm
           Boost::property_tree
           range-v3
           spdlog::spdlog
           tclap
           $<$<BOOL:${MSVC}>:${WinMM_LIBRARY}> # needed for timeGetTime
           $<$<BOOL:${OGS_BUILD_GUI}>:Qt5::Xml>
           $<$<BOOL:${OGS_BUILD_GUI}>:Qt5::XmlPatterns>
           $<$<BOOL:${OGS_USE_PETSC}>:PkgConfig::PETSC>
    PRIVATE xmlpatch Boost::interprocess
)

target_compile_definitions(${ADD_SYCL_ARGS_TARGET} PUBLIC
    EIGEN_SYCL_TRISYCL
    $<$<BOOL:${TRISYCL_NO_ASYNC}>:TRISYCL_NO_ASYNC>
    $<$<BOOL:${TRISYCL_OPENCL}>:TRISYCL_OPENCL>
    $<$<BOOL:${TRISYCL_DEBUG}>:TRISYCL_DEBUG>
    $<$<BOOL:${TRISYCL_DEBUG_STRUCTORS}>:TRISYCL_DEBUG_STRUCTORS>
    $<$<BOOL:${TRISYCL_TRACE_KERNEL}>:TRISYCL_TRACE_KERNEL>
    $<$<BOOL:${LOG_NEEDED}>:BOOST_LOG_DYN_LINK>)

link_directories("${CMAKE_BINARY_DIR}/../../../fingerjetfxose/FingerJetFXOSE/libFRFXLL/src/$<$<BOOL:${IS_MULTI_CONFIG}>:$<$<CONFIG:Debug>:Debug>$<$<CONFIG:Release>:Release>>")

ExternalProject_Add(${COMPONENT_NAME}
    PREFIX ${COMPONENT_NAME}
    DOWNLOAD_DIR ${COMPONENT_NAME}
    STAMP_DIR ${COMPONENT_NAME}/stamp
    SOURCE_DIR ${COMPONENT_NAME}/src
    BINARY_DIR ${COMPONENT_NAME}/build
    LIST_SEPARATOR | # Use the alternate list separator
    ${OIDN_CLONE_URL}
    ${OIDN_URL_HASH}
    GIT_SHALLOW ON
    CMAKE_ARGS
      -DCMAKE_PREFIX_PATH=${CMAKE_PREFIX_PATH}
      -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
      -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
      -DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}
      -DCMAKE_INSTALL_PREFIX:PATH=${COMPONENT_PATH}
      -DCMAKE_INSTALL_INCLUDEDIR=${CMAKE_INSTALL_INCLUDEDIR}
      -DCMAKE_INSTALL_LIBDIR=${CMAKE_INSTALL_LIBDIR}
      -DCMAKE_INSTALL_DOCDIR=${CMAKE_INSTALL_DOCDIR}
      -DCMAKE_INSTALL_BINDIR=${CMAKE_INSTALL_BINDIR}
      $<$<BOOL:${BUILD_TBB}>:-DTBB_ROOT=${COMPONENT_PATH}>
      $<$<BOOL:${DOWNLOAD_ISPC}>:-DISPC_EXECUTABLE=${ISPC_PATH}>
      -DCMAKE_BUILD_TYPE=Release # XXX debug builds are currently broken
      -DOIDN_APPS=OFF
      -DOIDN_ZIP_MODE=ON # to set install RPATH
      -DOIDN_DEVICE_SYCL=${BUILD_GPU_SUPPORT}
      -DCMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES}
      -DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET}
    PATCH_COMMAND ${OIDN_PATCH_COMMAND}
    BUILD_COMMAND ${DEFAULT_BUILD_COMMAND}
    BUILD_ALWAYS ${ALWAYS_REBUILD}
  )

add_compile_options($<$<BOOL:${SURGE_XT_WARNINGS_ARE_ERRORS}>:-Werror>)

target_sources(
  quda_cpp
  PRIVATE
    $<IF:$<BOOL:${QUDA_MPI}>,communicator_mpi.cpp,$<IF:$<BOOL:${QUDA_QMP}>,communicator_qmp.cpp,communicator_single.cpp>>
)

target_include_directories(secp256k1 INTERFACE
  # Add the include path for parent projects so that they don't have to manually add it.
  $<BUILD_INTERFACE:$<$<NOT:$<BOOL:${PROJECT_IS_TOP_LEVEL}>>:${PROJECT_SOURCE_DIR}/include>>
  $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
)

target_compile_definitions(keyledsd PRIVATE KEYLEDSD_MODULES_STATIC=1 $<$<BOOL:${NO_DBUS}>:NO_DBUS>)

ExternalProject_Add("${stdlib_target}-core"
        SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/Runtimes/Core"
        # TODO: Add this once we're ready to start swapping out the libraries
        #       for testing
        # INSTALL_DIR "${CMAKE_BINARY_DIR}/"

        DEPENDS PopulateRuntimeSourceDir
        # To ensure incremental builds work as expected
        BUILD_ALWAYS 1
        CMAKE_ARGS
          -DCMAKE_INSTALL_LIBDIR:FILEPATH=lib
          # Compiler will see mismatched swift modules and fail initial checks
          -DCMAKE_Swift_COMPILER_WORKS:BOOLEAN=YES
          -DBUILD_SHARED_LIBS:BOOLEAN=YES # TODO: Make this configurable
          ${stdlib_cache_file_flag}
          ${stdlib_deployment_version_flag}
          -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
          -DCMAKE_INSTALL_PREFIX:FILEPATH=<INSTALL_DIR>
          -DCMAKE_Swift_COMPILER:FILEPATH=$<IF:$<BOOL:${CMAKE_CROSSCOMPILING}>,${CMAKE_Swift_COMPILER},$<PATH:REPLACE_FILENAME,$<TARGET_FILE:swift-frontend>,swiftc>>
          -DCMAKE_C_COMPILER:FILEPATH=${CMAKE_C_COMPILER}
          -DCMAKE_CXX_COMPILER:FILEPATH=${CMAKE_CXX_COMPILER}
          -DCMAKE_Swift_COMPILER_TARGET:STRING=${stdlib_target_triple}
          -DCMAKE_C_COMPILER_TARGET:STRING=${stdlib_target_triple}
          -DCMAKE_CXX_COMPILER_TARGET:STRING=${stdlib_target_triple}
          -DCMAKE_COLOR_DIAGNOSTICS:BOOLEAN=${CMAKE_COLOR_DIAGNOSTICS}
          -DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}
          -DSwiftCore_INSTALL_NESTED_SUBDIR=YES
          -DSwiftCore_ENABLE_CONCURRENCY=${build_concurrency})

add_compile_options($<$<BOOL:${MSVC_IDE}>:/MP>)